/***************************************************************************/
/*                                                                         */
/*  ahangles.h                                                             */
/*                                                                         */
/*    A routine used to compute vector angles with limited accuracy        */
/*    and very high speed (body).                                          */
/*                                                                         */
/*  Copyright 2000 Catharon Productions Inc.                               */
/*  Author: David Turner                                                   */
/*                                                                         */
/*  This file is part of the Catharon Typography Project and shall only    */
/*  be used, modified, and distributed under the terms of the Catharon     */
/*  Open Source License that should come with this file under the name     */
/*  `CatharonLicense.txt'.  By continuing to use, modify, or distribute    */
/*  this file you indicate that you have read the license and              */
/*  understand and accept it fully.                                        */
/*                                                                         */
/*  Note that this license is compatible with the FreeType license.        */
/*                                                                         */
/***************************************************************************/


#include "ahangles.h"


/* the following table has been automatically generated with */
/* the `mather.py' Python script                             */

const AH_Angle ah_arctan[1L << AH_ATAN_BITS] =
{
	0,  0,  1,  1,  1,  2,  2,  2,
	3,  3,  3,  3,  4,  4,  4,  5,
	5,  5,  6,  6,  6,  7,  7,  7,
	8,  8,  8,  9,  9,  9, 10, 10,
	10, 10, 11, 11, 11, 12, 12, 12,
	13, 13, 13, 14, 14, 14, 14, 15,
	15, 15, 16, 16, 16, 17, 17, 17,
	18, 18, 18, 18, 19, 19, 19, 20,
	20, 20, 21, 21, 21, 21, 22, 22,
	22, 23, 23, 23, 24, 24, 24, 24,
	25, 25, 25, 26, 26, 26, 26, 27,
	27, 27, 28, 28, 28, 28, 29, 29,
	29, 30, 30, 30, 30, 31, 31, 31,
	31, 32, 32, 32, 33, 33, 33, 33,
	34, 34, 34, 34, 35, 35, 35, 35,
	36, 36, 36, 36, 37, 37, 37, 38,
	38, 38, 38, 39, 39, 39, 39, 40,
	40, 40, 40, 41, 41, 41, 41, 42,
	42, 42, 42, 42, 43, 43, 43, 43,
	44, 44, 44, 44, 45, 45, 45, 45,
	46, 46, 46, 46, 46, 47, 47, 47,
	47, 48, 48, 48, 48, 48, 49, 49,
	49, 49, 50, 50, 50, 50, 50, 51,
	51, 51, 51, 51, 52, 52, 52, 52,
	52, 53, 53, 53, 53, 53, 54, 54,
	54, 54, 54, 55, 55, 55, 55, 55,
	56, 56, 56, 56, 56, 57, 57, 57,
	57, 57, 57, 58, 58, 58, 58, 58,
	59, 59, 59, 59, 59, 59, 60, 60,
	60, 60, 60, 61, 61, 61, 61, 61,
	61, 62, 62, 62, 62, 62, 62, 63,
	63, 63, 63, 63, 63, 64, 64, 64
};


LOCAL_FUNC
AH_Angle  ah_angle( FT_Vector*  v ) {
	FT_Pos dx, dy;
	AH_Angle angle;


	dx = v->x;
	dy = v->y;

	/* check trivial cases */
	if ( dy == 0 ) {
		angle = 0;
		if ( dx < 0 ) {
			angle = AH_PI;
		}
		return angle;
	} else if ( dx == 0 )   {
		angle = AH_HALF_PI;
		if ( dy < 0 ) {
			angle = -AH_HALF_PI;
		}
		return angle;
	}

	angle = 0;
	if ( dx < 0 ) {
		dx = -v->x;
		dy = -v->y;
		angle = AH_PI;
	}

	if ( dy < 0 ) {
		FT_Pos tmp;


		tmp = dx;
		dx  = -dy;
		dy  = tmp;
		angle -= AH_HALF_PI;
	}

	if ( dx == 0 && dy == 0 ) {
		return 0;
	}

	if ( dx == dy ) {
		angle += AH_PI / 4;
	} else if ( dx > dy ) {
		angle += ah_arctan[FT_DivFix( dy, dx ) >> ( 16 - AH_ATAN_BITS )];
	} else {
		angle += AH_HALF_PI -
				 ah_arctan[FT_DivFix( dx, dy ) >> ( 16 - AH_ATAN_BITS )];
	}

	if ( angle > AH_PI ) {
		angle -= AH_2PI;
	}

	return angle;
}


/* END */
